package com.wct.mall.service;

import com.google.common.base.Preconditions;
import com.wct.mall.domain.PmsBrand;
import com.wct.mall.exception.ParamException;
import com.wct.mall.mapper.PmsBrandMapper;
import com.wct.mall.util.BeanValidator;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;

/**
 * 商品品牌表
 * @author WEI
 */
@Service
@Slf4j
public class PmsBrandService {

    @Resource
    private PmsBrandMapper pmsBrandMapper;

    public int insertSelective(PmsBrand record) {
        return pmsBrandMapper.insertSelective(record);
    }

    /**
     * 保存
     */
    public void insert(PmsBrand param) {
        // 校验参数是否合法
        BeanValidator.check(param);
        // 检查品牌名称是否存在
        if (checkExist(param.getName())) {
            throw new ParamException("品牌名称已存在");
        }
        PmsBrand brand = PmsBrand.builder()
                .name(param.getName())
                .firstLetter(param.getFirstLetter())
                .sort(param.getSort())
                .factoryStatus(param.getFactoryStatus())
                .productCount(param.getProductCount())
                .productCommentCount(param.getProductCommentCount())
                .logo(param.getLogo())
                .bigPic(param.getBigPic())
                .brandStory(param.getBrandStory())
                .build();

        // TODO 设置创建时间的操作者信息
        brand.setCreateTime(new Date());
        brand.setUpdateTime(new Date());
        brand.setOperateIp("127.0.0.1");
        brand.setOperator("admin");
        // 保存到数据库中
        log.debug("save ：{}", brand);
        pmsBrandMapper.insertSelective(brand);
    }

    /**
     * 更新
     */
    @Transactional(rollbackFor = Exception.class)
    public void update(PmsBrand param) {
// 校验参数是否合法
        BeanValidator.check(param);
        // 检查品牌名称是否存在
        if (checkExist(param.getName())) {
            throw new ParamException("品牌名称已存在");
        }
        // 根据传递过来的id查询数据是否存在
        PmsBrand before = pmsBrandMapper.selectByPrimaryKey(param.getId());
        Preconditions.checkNotNull(before, "待更新的品牌不存在");

        PmsBrand after = PmsBrand.builder()
                .id(param.getId())
                .name(param.getName())
                .firstLetter(param.getFirstLetter())
                .sort(param.getSort())
                .factoryStatus(param.getFactoryStatus())
                .productCount(param.getProductCount())
                .productCommentCount(param.getProductCommentCount())
                .logo(param.getLogo())
                .bigPic(param.getBigPic())
                .brandStory(param.getBrandStory())
                .build();

        // TODO 设置创建时间的操作者信息
//        after.setCreateTime(new Date());
        after.setUpdateTime(new Date());
        after.setOperateIp("127.0.0.1");
        after.setOperator("admin");
        // 保存到数据库中
        pmsBrandMapper.updateByPrimaryKeySelective(after);
    }

    /**
     * 删除
     */
    public void delete(Integer id) {
        // 根据传递过来的id查询数据是否存在
        PmsBrand brand = pmsBrandMapper.selectByPrimaryKey(id);
        Preconditions.checkNotNull(brand, "待删除的品牌不存在，无法删除");
        // TODO 检查是否有商品关联该品牌
        if (true) {
            throw new ParamException("当前品牌下有商品，无法删除");
        }
        pmsBrandMapper.deleteByPrimaryKey(id);
    }

    /**
     * 根据ID查询
     */
    public PmsBrand get(Integer id) {
        return pmsBrandMapper.selectByPrimaryKey(id);
    }
    /**
     * 查询所有
     */
    public List<PmsBrand> list() {
        return pmsBrandMapper.getAll();
    }

    /**
     * 检查品牌名称是否存在
     */
    private boolean checkExist(String name) {
        return pmsBrandMapper.countByName(name) > 0;
    }
}


